#include "abc_common.cpp"
#include <vector>
#include <string>
#include <algorithm>
#include <sstream>
#include <memory>
#include <iostream>
void FillFunctionInfo(AbcFunction *abcFunc, AbckitCoreFunction *func, const AbcClass *abcClass,
                      const AbcModule *abcModule)
{
    abcFunc->func = func;

    // 获取函数名
    std::string funcName = g_implI->abckitStringToString(g_implI->functionGetName(func));
    abcFunc->funcName = funcName;

    // 获取父类信息
    // AbckitCoreClass* parentClass = g_implI->functionGetParentClass(func);
    // if (parentClass != nullptr)
    // {
    //     std::string parentClassName =
    //         g_implI->abckitStringToString(g_implI->classGetName(parentClass));
    //     abcFunc->parentClassName = parentClassName;
    // }

    // 获取命名空间信息
    AbckitCoreNamespace *namespaceName = g_implI->functionGetParentNamespace(func);
    if (namespaceName != nullptr)
    {
        AbckitString *namespaceNameStr = g_implI->namespaceGetName(namespaceName);
        abcFunc->entityInfo.parentNamespaceName = g_implI->abckitStringToString(namespaceNameStr);
    }

    // 获取父函数信息
    AbckitCoreFunction *parentFunction = g_implI->functionGetParentFunction(func);
    if (parentFunction != nullptr)
    {
        std::string parentFuncName =
            g_implI->abckitStringToString(g_implI->functionGetName(parentFunction));
        abcFunc->entityInfo.parentFuncName = parentFuncName;
    }

    // 设置是否为匿名函数
    abcFunc->isAnonymous = g_implI->functionIsAnonymous(func);

    // 如果提供了类信息，则从类中获取相关信息
    if (abcClass != nullptr)
    {
        abcFunc->entityInfo.className = abcClass->entityInfo.className;
        abcFunc->entityInfo.moduleName = abcClass->entityInfo.moduleName;
        abcFunc->entityInfo.path = abcClass->entityInfo.path;
    }
    // 如果没有类信息但提供了模块信息，则从模块中获取
    else if (abcModule != nullptr)
    {
        abcFunc->entityInfo.moduleName = abcModule->entityInfo.moduleName;
        abcFunc->entityInfo.path = abcModule->entityInfo.path;
    }
}
struct ProcessedScanConfig
{
    std::vector<std::string> modules;
    std::string normalizedPath;
    std::vector<std::string> classNames;
    std::vector<std::string> methodNames;
};

// 扫描配置结构体定义
struct ScanConfig
{
    std::string module;    // 模块名，支持通配符如 "entry|common|*"
    std::string path;      // 路径，可以是 "src/main/ets/pages/*" 或 "src.main.ets.pages" 格式
    std::string className; // 类名，支持通配符如 "xxx|yyy|*"
    std::string methName;  // 方法名，支持通配符如 "xxx|yyy|*"

    ScanConfig() = default;

    // 初始化列表构造函数
    ScanConfig(const std::string &mod, const std::string &p,
               const std::string &cls, const std::string &meth)
        : module(mod), path(p), className(cls), methName(meth) {}
};

class ScanConfigProcessor
{
public:
    // 将带分隔符的字符串转换为数组
    static std::vector<std::string> stringToArray(const std::string &str, char delimiter = '|')
    {
        std::vector<std::string> result;
        std::istringstream ss(str);
        std::string item;

        while (std::getline(ss, item, delimiter))
        {
            // 移除星号(*)通配符
            item.erase(std::remove(item.begin(), item.end(), '*'), item.end());
            // 去除前后空格
            item.erase(0, item.find_first_not_of(' '));
            item.erase(item.find_last_not_of(' ') + 1);

            if (!item.empty())
            {
                result.push_back(item);
            }
        }

        return result;
    }

    // 标准化路径格式，统一使用斜杠
    static std::string normalizePath(const std::string &path)
    {
        std::string normalized = path;

        // 将点号(.)替换为斜杠(/)
        std::replace(normalized.begin(), normalized.end(), '.', '/');

        // 移除星号(*)通配符
        normalized.erase(std::remove(normalized.begin(), normalized.end(), '*'), normalized.end());

        // 去除前后空格
        normalized.erase(0, normalized.find_first_not_of(' '));
        normalized.erase(normalized.find_last_not_of(' ') + 1);

        return normalized;
    }

    // 处理完整的ScanConfig配置，返回指向处理结果的指针
    static std::shared_ptr<ProcessedScanConfig> processScanConfig(const ScanConfig &scan)
    {
        auto processedConfig = std::make_shared<ProcessedScanConfig>();

        // 1. 转换模块名为数组（如果为空则生成空数组）
        if (!scan.module.empty())
        {
            processedConfig->modules = stringToArray(scan.module);
        }

        // 2. 标准化路径格式（斜杠或点都转成斜杠），并移除星号
        if (!scan.path.empty())
        {
            processedConfig->normalizedPath = normalizePath(scan.path);
        }

        // 3. 转换类名为数组（如果为空则生成空数组）
        if (!scan.className.empty())
        {
            processedConfig->classNames = stringToArray(scan.className);
        }

        // 4. 转换方法名为数组（如果为空则生成空数组）
        if (!scan.methName.empty())
        {
            processedConfig->methodNames = stringToArray(scan.methName);
        }

        return processedConfig;
    }
};

bool ShouldProcessModule(const std::string &moduleName, const std::shared_ptr<ProcessedScanConfig> &processedScan)
{
    // 处理所有模块
    if (processedScan->modules.empty())
    {
        return true;
    }

    // 检查模块是否在允许列表中
    for (const auto &targetModule : processedScan->modules)
    {
        // 转换为小写进行比较
        std::string lowerModuleName = moduleName;
        std::string lowerTargetModule = targetModule;

        std::transform(lowerModuleName.begin(), lowerModuleName.end(), lowerModuleName.begin(), ::tolower);
        std::transform(lowerTargetModule.begin(), lowerTargetModule.end(), lowerTargetModule.begin(), ::tolower);
        if (lowerModuleName == lowerTargetModule)
        {
            return true;
        }
    }

    return false;
}

bool ShouldProcessPath(const std::string &filePath, const std::shared_ptr<ProcessedScanConfig> &processedScan)
{
    // 如果路径为空或processedScan路径为空，则匹配所有路径
    if (processedScan->normalizedPath.empty())
    {
        return true;
    }

    // 转换为小写进行比较
    std::string lowerFilePath = filePath;
    std::string lowerNormalizedPath = processedScan->normalizedPath;

    std::transform(lowerFilePath.begin(), lowerFilePath.end(), lowerFilePath.begin(), ::tolower);
    std::transform(lowerNormalizedPath.begin(), lowerNormalizedPath.end(), lowerNormalizedPath.begin(), ::tolower);

    // 检查filePath是否以normalizedPath开头
    if (lowerFilePath.length() >= lowerNormalizedPath.length() &&
        lowerFilePath.substr(0, lowerNormalizedPath.length()) == lowerNormalizedPath)
    {
        return true;
    }

    return false;
}

bool ShouldProcessClass(const std::string &className, const std::shared_ptr<ProcessedScanConfig> &processedScan)
{
    // 扫描所有类
    if (processedScan->classNames.empty())
    {
        return true;
    }
    for (const auto &allowedClassName : processedScan->classNames)
    {
        // 转换为小写进行比较
        std::string lowerClassName = className;
        std::string lowerAllowedClassName = allowedClassName;

        std::transform(lowerClassName.begin(), lowerClassName.end(), lowerClassName.begin(), ::tolower);
        std::transform(lowerAllowedClassName.begin(), lowerAllowedClassName.end(), lowerAllowedClassName.begin(), ::tolower);

        if (lowerAllowedClassName == lowerClassName)
        {
            return true;
        }
    }
    return false;
}

bool ShouldProcessMethod(const std::string &methodName, const std::shared_ptr<ProcessedScanConfig> &processedScan)
{
    // 如果方法名列表为空，则扫描所有方法
    if (processedScan->methodNames.empty())
    {
        return true; // 处理所有方法
    }

    // 检查当前方法名是否在允许的方法名列表中（忽略大小写）
    for (const auto &allowedMethodName : processedScan->methodNames)
    {
        // 转换为小写进行比较
        std::string lowerMethodName = methodName;
        std::string lowerAllowedMethodName = allowedMethodName;

        std::transform(lowerMethodName.begin(), lowerMethodName.end(), lowerMethodName.begin(), ::tolower);
        std::transform(lowerAllowedMethodName.begin(), lowerAllowedMethodName.end(), lowerAllowedMethodName.begin(), ::tolower);

        // 支持通配符匹配，这里简单实现完全匹配（忽略大小写）
        if (lowerAllowedMethodName == lowerMethodName)
        {
            return true; // 找到了匹配的方法，应该处理它
        }
        // 如果需要支持通配符，可以在这里添加更复杂的匹配逻辑
    }

    // 方法名不在允许列表中，不应该处理该方法
    return false;
}